package com.erp.erp_ui.business.controller;

import com.alibaba.fastjson.JSONObject;
import com.erp.erp_entitys.Customer.CustomerInformationRecordReq;
import com.erp.erp_entitys.Customer.CustomerInformationRecordRes;
import com.erp.erp_entitys.User.UserEntity;
import com.erp.erp_entitys.business.req.*;
import com.erp.erp_entitys.business.rsp.CompanyLogo;
import com.erp.erp_entitys.business.rsp.DeliveryDateInfoRes;
import com.erp.erp_entitys.business.rsp.ExportExpensesRes;
import com.erp.erp_entitys.business.rsp.ImportExportContractProductPartsRsp;
import com.erp.erp_entitys.warehouse.rsp.ProductInfoRsp;
import com.erp.erp_servers.Ftp.IFtpService;
import com.erp.erp_ui.base.Base;
import com.erp.erp_ui.business.req.*;
import com.erp.erp_ui.business.service.ExportContractService;
import com.erp.erp_ui.business.vo.*;
import com.erp.erp_ui.money.req.OperationReq;
import com.erp.utils.R;
import com.erp.utils.ResultStatusEnum;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName : ExportContractController
 * @Description : 出口业务-外销控制层
 * @Author : lst
 * @Date: 2021-01-17 11:20
 */
@Controller
@RequestMapping(value = "exportContract")
public class ExportContractController extends Base {

    /**
     * 日志
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(ExportContractController.class);

    /**
     * 外销业务逻辑接口
     */
    private final ExportContractService exportContractService;
    private final IFtpService ftpService;

    @Autowired
    public ExportContractController(ExportContractService exportContractService, IFtpService ftpService) {
        this.exportContractService = exportContractService;
        this.ftpService = ftpService;
    }


    /**
     * 导入报价
     *
     * @param req 查询参数
     * @return 报价信息
     */
    @GetMapping("/getImportOfferByPage")
    @ResponseBody
    public R getImportOffer(ImportOfferReq req) {
        try {
            LOGGER.info("出口业务-外销-获取报价信息:req=" + req.toString());
            PageInfo<ImportOfferVo> pageInfo = exportContractService.getImportOffer(req);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-获取报价信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取报价明细
     *
     * @param id 报价id
     * @return 报价明细
     */
    @GetMapping("/getImportOfferDetail")
    @ResponseBody
    public R getImportOfferDetail(Integer id) {
        try {
            LOGGER.info("出口业务-外销-获取报价明细:id=" + id);
            List<OfferProductDetailVo> detailList = exportContractService.getImportOfferDetail(id);
            return R.build(detailList);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-获取报价明细异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 新增、修改
     *
     * @param req 新增、修改入参
     * @return 新增、修改结果
     */
    @PostMapping("/add")
    @ResponseBody
    public R add(@Validated @RequestBody AddExportContractReq req) {
        try {
            LOGGER.info("出口业务-外销-新增、修改 req=" + req.toString());
            UserEntity user = (UserEntity) this.getBean("user");
            String name = user.getName();
            String code = user.getCode();
            return exportContractService.add(req, name, code);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-新增、修改异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 首页-分页列表查询
     *
     * @param req 查询参数
     * @return 外销信息
     */
    @GetMapping("/getListByPage")
    @ResponseBody
    public R getListByPage(ExportContractPageListReq req) {
        try {
            LOGGER.info("首页-分页列表查询 req=" + req.toString());
            PageInfo<ExportContractPageListVo> pageInfo = exportContractService.getListByPage(req);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("首页-分页列表查询异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 首页-列表查询
     *
     * @param req 查询参数
     * @return 外销信息
     */
    @GetMapping("/getList")
    @ResponseBody
    public R getList(ExportContractPageListReq req) {
        try {
            LOGGER.info("首页-列表查询 req=" + req.toString());
            List<ExportContractPageListVo> list = exportContractService.getList(req);
            return R.build(list);
        } catch (Exception e) {
            LOGGER.info("首页-列表查询异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 详情
     *
     * @param id 详情id
     * @return 详情信息
     */
    @GetMapping("/detail")
    @ResponseBody
    public R detail(Integer id) {
        try {
            LOGGER.info("出口业务-外销-详情：id=" + id);
            ExportContractDetailVo detailVo = exportContractService.detail(id);
            return R.build(detailVo);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-详情异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 出口业务-删除
     *
     * @param req 删除条件
     * @return 删除结果
     */
    @PostMapping("/delete")
    @ResponseBody
    public R delete(@RequestBody OperationReq req) {
        try {
            LOGGER.info("出口业务-外销-删除 req=" + req);
            exportContractService.delete(req);
            return R.build("");
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-删除异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }

    }

    /**
     * 数据操作接口
     *
     * @param req
     * @return
     */
    @PostMapping("/operation")
    @ResponseBody
    public R operation(@RequestBody OperationReq req) {
        try {
            LOGGER.info("出口业务-外销-数据操作接口 req=" + req);
            UserEntity user = (UserEntity) this.getBean("user");
            return exportContractService.operation(req, user);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-数据操作接口异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 校验是否可以回退数据 1:采购调用 2:出运计划调用 3:调拨调用 0:未被调用
     *
     * @param id     外销id
     * @param billNo 外销单号
     * @return 1:采购调用 2:出运计划调用 3:调拨调用 0:未被调用
     */
    @GetMapping("/checkIsCanModified")
    @ResponseBody
    public R checkIsCanModified(Integer id, String billNo) {
        try {
            LOGGER.info("出口业务-外销-校验是否可修改 id=" + id + ",billNo=" + billNo);
            int result = exportContractService.checkDataIsRollBack(id, billNo);
            return R.build(result);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-校验是否可修改异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取下游调用情况
     * @param id 外销ID
     * @param billNo 外销单号
     * @return 下游调用情况
     */
    @GetMapping("/getUsedInfoByConcatNo")
    @ResponseBody
    public R getUsedInfoByConcatNo(Integer id, String billNo) {
        try {
            LOGGER.info("出口业务-外销-获取下游调用情况 id=" + id + ",billNo=" + billNo);
            int result = exportContractService.getUsedInfoByConcatNo(id, billNo);
            return R.build(result);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-获取下游调用情况异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 通过采购单号获取已做计划数量
     *
     * @param purchaseNo 采购单号
     * @return 已做计划数量
     */
    @GetMapping("/getPlanCountByPurchaseNo")
    @ResponseBody
    public R getPlanCountByPurchaseNo(String purchaseNo) {
        try {
            LOGGER.info("出口业务-外销-通过采购单号获取已做计划数量 purchaseNo=" + purchaseNo);
            int count = exportContractService.getPlanCountByPurchaseNo(purchaseNo);
            return R.build(count);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-通过采购单号获取已做计划数量异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 数据批量操作接口
     * @param req 操作类型
     * @return 操作结果
     */
    @PostMapping("/batchOperation")
    @ResponseBody
    public R batchOperation(@RequestBody BatchOperationReq req) {
        try {
            LOGGER.info("出口业务-外销-数据批量操作 req=" + req);
            UserEntity user = (UserEntity)this.getBean("user");
            return exportContractService.batchOperation(req, user.getMsn());
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-数据批量操作异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 单据转移接口
     * @param req 操作类型
     * @return 操作结果
     */
    @PostMapping("/batchUpdateSalesman")
    @ResponseBody
    public R batchUpdateSalesman(@RequestBody BatchOperationReq req) {
        try {
            LOGGER.info("出口业务-外销-单据转移 req=" + req);
            return exportContractService.batchUpdateSalesman(req);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-单据转移异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 导入-获取外销主表信息
     *
     * @param req 查询条件入参实体
     * @return 外销主表信息
     */
    @GetMapping("/import/getContractByPage")
    @ResponseBody
    public R getContractByPage(ImportExportContractReq req) {
        try {
            LOGGER.info("出口业务-外销-导入-获取外销主表信息：req=" + req.toString());
            PageInfo<ImportExportContractVo> pageInfo = exportContractService.getContractByPage(req);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-导入-获取外销主表信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 导入-获取外销产品信息
     *
     * @param id 外销主表id
     * @return 外销产品信息
     */
    @GetMapping("/import/getContractProductByPage")
    @ResponseBody
    public R getContractProductByPage(Integer id) {
        try {
            LOGGER.info("出口业务-外销-导入-获取外销产品信息：id=" + id);
            PageInfo<ImportExportContractProductVo> pageInfo = exportContractService.getContractProductByPage(id);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-导入-获取外销产品信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 导入-获取外销产品信息(不分页)
     *
     * @param id 外销主表id
     * @return 外销产品信息
     */
    @GetMapping("/import/getContractProduct")
    @ResponseBody
    public R getContractProduct(Integer id) {
        try {
            LOGGER.info("出口业务-外销-导入-获取外销产品信息(不分页)：id=" + id);
            List<ImportExportContractProductVo> productVoList = exportContractService.getContractProduct(id);
            return R.build(productVoList);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-导入-获取外销产品信息(不分页)异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 导入-获取外销产品配件信息
     *
     * @param id 外销产品id
     * @return 外销产品配件信息
     */
    @GetMapping("/import/getContractProductPartsByPage")
    @ResponseBody
    public R getContractProductPartsByPage(Integer id) {
        try {
            LOGGER.info("出口业务-外销-导入-获取外销产品配件信息：id=" + id);
            PageInfo<ImportExportContractProductPartsVo> pageInfo = exportContractService.getContractProductPartsByPage(id);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-导入-获取外销产品配件信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 导入-获取外销产品配件信息(不分页)
     *
     * @param id 外销产品id
     * @return 外销产品配件信息
     */
    @GetMapping("/import/getContractProductParts")
    @ResponseBody
    public R getContractProductParts(Integer id) {
        try {
            LOGGER.info("出口业务-外销-导入-获取外销产品配件信息：id=" + id);
            List<ImportExportContractProductPartsVo> list = exportContractService.getContractProductParts(id);
            return R.build(list);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-导入-获取外销产品配件信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 导入-获取外销产品配件信息
     *
     * @param id 外销产品id
     * @return 外销产品配件信息
     */
    @GetMapping("/import/getContractProductPartsById")
    @ResponseBody
    public R<List<ImportExportContractProductPartsRsp>> getContractProductPartsById(Integer id) {
        try {
            LOGGER.info("出口业务-外销-导入-获取外销产品配件信息：id=" + id);
            List<ImportExportContractProductPartsRsp> list = exportContractService.getContractProductPartsById(id);
            return R.build(list);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-导入-获取外销产品配件信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 导入-获取外销费用信息
     *
     * @param id 外销主表id
     * @return 外销费用信息
     */
    @PostMapping("/import/getExportContractCostByParentIds")
    @ResponseBody
    public R getExportContractCostByParentIds(String[] ids) {
        try {
            List<Integer> list=new ArrayList<>();
            for(int i=0;i<ids.length;i++){
                list.add(Integer.parseInt(ids[i].replace("[","").replace("]","")));
            }
            LOGGER.info("出口业务-外销-导入-获取外销费用信息：id=" + list);
            List<ExportContractCostDetailVo> costList = exportContractService.getExportContractCostByParentIds(list);
            return R.build(costList);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-导入-获取外销费用信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取外销产品表中存在指定报价单中的产品数量
     *
     * @param req 查询条件
     * @return 外销产品表中存在指定报价单中的产品数量
     */
    @GetMapping("/getRemainingQuantity")
    @ResponseBody
    public R getRemainingQuantity(RemainingQuantityInfoReq req) {
        try {
            LOGGER.info("出口业务-外销-导入-获取外销产品表中存在指定报价单中的产品数量：req=" + req.toString());
            BigDecimal sum = exportContractService.getRemainingQuantity(req);
            return R.build(sum);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-导入-获取外销产品表中存在指定报价单中的产品数量异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取库存现状
     *
     * @param productCode       产品编码
     * @param specificationCode 规格编码
     * @return 库存现状
     */
    @GetMapping("/getInventoryStatus")
    @ResponseBody
    public R getInventoryStatus(String productCode, String specificationCode) {
        try {
            LOGGER.info("出口业务-外销-获取库存现状:productCode=" + productCode + ",specificationCode=" + specificationCode);
            PageInfo<StockInfoVo> pageInfo = exportContractService.getInventoryStatus(productCode, specificationCode);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-获取库存现状异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 统计1
     *
     * @return 统计信息1
     */
    @GetMapping(value = "statistics/getContractStatisticsOneByPage")
    @ResponseBody
    public R getContractStatisticsOne(ContractStatisticsOneReq req) {
        try {
            LOGGER.info("出口业务-外销-统计1");
            PageInfo<ContractStatisticsOneVo> pageInfo = exportContractService.getContractStatisticsOne(req);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-统计1异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 统计1导出Excel
     *
     * @return 统计信息1
     */
    @GetMapping(value = "statistics/export/getContractStatisticsOneInfo")
    @ResponseBody
    public R getContractStatisticsOneInfo(ContractStatisticsOneReq req) {
        try {
            LOGGER.info("出口业务-外销-统计1-导出Excel");
            JSONObject obj = exportContractService.getContractStatisticsOneInfo(req);
            return R.build(obj);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-统计1-导出Excel异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 统计2
     *
     * @return 统计信息2
     */
    @GetMapping(value = "statistics/getContractStatisticsTwoByPage")
    @ResponseBody
    public R getContractStatisticsTwo(ContractStatisticsTwoReq req) {
        try {
            LOGGER.info("出口业务-外销-统计2");
            PageInfo<ContractStatisticsTwoVo> pageInfo = exportContractService.getContractStatisticsTwo(req);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-统计2异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 统计2导出Excel
     *
     * @return 统计信息2
     */
    @GetMapping(value = "statistics/export/getContractStatisticsTwoInfo")
    @ResponseBody
    public R getContractStatisticsTwoInfo(ContractStatisticsTwoReq req) {
        try {
            LOGGER.info("出口业务-外销-统计2-导出Excel");
            JSONObject obj = exportContractService.getContractStatisticsTwoInfo(req);
            return R.build(obj);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-统计2-导出Excel异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 统计3
     *
     * @return 统计信息3
     */
    @GetMapping(value = "statistics/getContractStatisticsThreeByPage")
    @ResponseBody
    public R getContractStatisticsThree(ContractStatisticsOneReq req) {
        try {
            LOGGER.info("出口业务-外销-统计3");
            PageInfo<ContractStatisticsOneVo> pageInfo = exportContractService.getContractStatisticsThree(req);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-统计3异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 统计3导出Excel
     *
     * @return 统计信息3
     */
    @GetMapping(value = "statistics/export/getContractStatisticsThreeInfo")
    @ResponseBody
    public R getContractStatisticsThreeInfo(ContractStatisticsOneReq req) {
        try {
            LOGGER.info("出口业务-外销-统计3-导出Excel");
            JSONObject obj = exportContractService.getContractStatisticsThreeInfo(req);
            return R.build(obj);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-统计3-导出Excel异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    /**
     * 根据参数返回logo的url
     *
     * @param id
     * @return
     */
    @GetMapping("/getImgLogoUrl")
    @ResponseBody
    public R getImgLogoUrl(Integer id) {
        try {
            LOGGER.info("出口业务-外销-根据参数返回logo的url");
            CompanyLogo companyLogo = exportContractService.getImgLogoUrl(id);
            if (companyLogo.getcLogo() != null) {
                ftpService.ftpUpload(companyLogo.getcLogo());
            }
            if (companyLogo.getSeal() != null) {
                ftpService.ftpUpload(companyLogo.getSeal());
            }

            return R.build(companyLogo);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-根据参数返回logo的url" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取本月外销合同数量
     *
     * @return 本月外销合同数量
     */
    @GetMapping("/statistics/getExportBillNoCount")
    @ResponseBody
    public R getExportBillNoCount() {
        try {
            LOGGER.info("出口业务-外销-获取本月外销合同数量信息");
            UserEntity user = (UserEntity) this.getBean("user");
            String name = user.getName();
            String code = user.getCode();
            long count = exportContractService.getExportBillNoCount(name, code);
            return R.build(count);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-获取本月外销合同数量异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取本月外销合同总额USD
     *
     * @return 本月外销合同总额USD
     */
    @GetMapping("/statistics/getTotalContractAmount")
    @ResponseBody
    public R getTotalContractAmount() {
        try {
            LOGGER.info("出口业务-外销-获取本月外销合同总额USD信息");
            UserEntity user = (UserEntity) this.getBean("user");
            String name = user.getName();
            String code = user.getCode();
            BigDecimal count = exportContractService.getTotalContractAmount(name, code);
            return R.build(count);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-获取本月外销合同总额USD异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取本月报价成交率
     *
     * @return 本月报价成交率
     */
    @GetMapping("/statistics/getOfferTurnoverRate")
    @ResponseBody
    public R getOfferTurnoverRate() {
        try {
            LOGGER.info("出口业务-外销-获取本月报价成交率");
            UserEntity user = (UserEntity) this.getBean("user");
            String name = user.getName();
            String code = user.getCode();
            BigDecimal count = exportContractService.getOfferTurnoverRate(name, code);
            return R.build(count);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-获取本月报价成交率异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 控制台-获取外销信息
     *
     * @return 外销信息
     */
    @GetMapping("/statistics/getStatisticsExportInfoByPage")
    @ResponseBody
    public R getStatisticsExportInfoByPage() {
        try {
            LOGGER.info("出口业务-控制台-外销-获取外销信息");
            UserEntity user = (UserEntity) this.getBean("user");
            String name = user.getName();
            String code = user.getCode();
            PageInfo<StatisticsExportInfoVo> pageInfo = exportContractService.getStatisticsExportInfoByPage(name, code);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("出口业务-控制台-外销-获取外销信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 按出运明细统计采购付款信息-导出
     *
     * @return 按出运明细统计采购付款信息
     */
    @GetMapping(value = "export/getStatisticsExportInfo")
    @ResponseBody
    public R getStatisticsExportInfo() {
        try {
            LOGGER.info("出口业务-控制台-外销-导出外销信息");
            UserEntity user = (UserEntity) this.getBean("user");
            String name = user.getName();
            String code = user.getCode();
            JSONObject obj = exportContractService.getStatisticsExportInfo(name, code);
            return R.build(obj);
        } catch (Exception e) {
            LOGGER.info("出口业务-控制台-外销-导出外销信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    /**
     * 金额转换英文
     *
     * @param id 外销单据id
     * @return
     */
    @GetMapping("numberParseToEnglish")
    public R numberParseToEnglish(Integer id) {
        try {
            LOGGER.info("金额转换英文");
            return exportContractService.update(id);
        } catch (Exception e) {
            LOGGER.info("金额转换英文信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }



    /**
     * 客户订单第一次记录 统计
     * @param req
     * @return
     */
    @RequestMapping("getFirstCustomerInfoListByPage")
    @ResponseBody
    public R getFirstCustomerInfoListByPage(CustomerInformationRecordReq req){
        try {
            UserEntity user = (UserEntity) this.getBean("user");
            if (StringUtils.isEmpty(req.getSalesmanCode()) && StringUtils.isEmpty(req.getDeptSalesmanCode()) ){
                req.setSalesmanCode(user.getCode());
            }

            PageInfo<CustomerInformationRecordRes> pageInfo= exportContractService.getFirstCustomerInfoListByPage(req);
            return R.build(0,"",pageInfo.getTotal(),pageInfo.getList());

        }catch (Exception e){
            e.printStackTrace();
            return R.buildError(ResultStatusEnum.ERROR);
        }
    }
    /**
     * 客户订单第一次记录-导出
     * @param req
     * @return
     */
    @RequestMapping("getFirstCustomerInfoListExport")
    @ResponseBody
    public R getFirstCustomerInfoListExport(CustomerInformationRecordReq req){
        try {
            JSONObject info= exportContractService.getFirstCustomerInfoExport(req);
            return R.build(info);
        }catch (Exception e){
            e.printStackTrace();
            return R.buildError(ResultStatusEnum.ERROR);
        }
    }


    /**
     * 外销产品交期一览表 统计
     * @param req
     * @return
     */
    @RequestMapping("getDeliveryDateInfoListByPage")
    @ResponseBody
    public R getDeliveryDateInfoListByPage(DeliveryDateInfoReq req){
        try {
            LOGGER.info("外销产品交期一览表 统计 req=" + req.toString());
            PageInfo<DeliveryDateInfoRes> pageInfo= exportContractService.getDeliveryDateInfoListByPage(req);
            return R.build(0,"",pageInfo.getTotal(),pageInfo.getList());
        }catch (Exception e){
            e.printStackTrace();
            LOGGER.info("外销产品交期一览表 统计异常 req=" + req.toString());
            return R.buildError(ResultStatusEnum.ERROR);
        }
    }
    /**
     * 外销产品交期一览表 导出
     * @param req
     * @return
     */
    @RequestMapping("getDeliveryDateInfoListExport")
    @ResponseBody
    public R getDeliveryDateInfoListExport(DeliveryDateInfoReq req){
        try {
            LOGGER.info("外销产品交期一览表 导出 req=" + req.toString());
            JSONObject info= exportContractService.getDeliveryDateInfoListExport(req);
            return R.build(info);
        }catch (Exception e){
            e.printStackTrace();
            LOGGER.info("外销产品交期一览表 导出异常 req=" + req.toString());
            return R.buildError(ResultStatusEnum.ERROR);
        }
    }

    /**
     * 客户订单总表
     *
     * @return 客户订单总表
     */
    @GetMapping(value = "statistics/getContractCustomerInfoByPage")
    @ResponseBody
    public R getContractCustomerInfoByPage(ContractCustomerInfoReq req) {
        try {
            LOGGER.info("出口业务-外销-客户订单总表 req=" + req.toString());
            PageInfo<ContractCustomerInfoVo> pageInfo = exportContractService.getContractCustomerInfoByPage(req);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-客户订单总表:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 客户订单总表-导出Excel
     *
     * @return 客户订单总表
     */
    @GetMapping(value = "statistics/export/getContractCustomerInfo")
    @ResponseBody
    public R getContractCustomerInfo(ContractCustomerInfoReq req) {
        try {
            LOGGER.info("出口业务-外销-客户订单总表-导出 req=" + req.toString());
            JSONObject obj = exportContractService.getContractCustomerInfo(req);
            return R.build(obj);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-客户订单总表-导出:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    /**
     * 外销费用统计--分页
     */
    @GetMapping(value = "statistics/getExportExpensesByPage")
    @ResponseBody
    public R getExportExpensesByPage(ExportExpensesReq req) {
        try {
            LOGGER.info("外销费用统计 req=" + req.toString());
            PageInfo<ExportExpensesRes> pageInfo = exportContractService.getExportExpensesByPage(req);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("外销费用统计异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }
    /**
     * 外销费用统计-导出Excel
     */
    @GetMapping(value = "statistics/export/getExportExpensesExport")
    @ResponseBody
    public R getExportExpensesExport(ExportExpensesReq req) {
        try {
            LOGGER.info("出口业务-外销-客户订单总表-导出 req=" + req.toString());
            JSONObject obj = exportContractService.getExportExpensesExport(req);
            return R.build(obj);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-客户订单总表-导出:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


    /**
     * 外销产品、配件终止、取消终止
     * @param req 操作入参
     * @return 操作状态
     */
    @PostMapping(value = "updateProductOrPartsStatus")
    @ResponseBody
    public R updateProductOrPartsStatus(@RequestBody UpdateProductOrPartsStatusReq req) {
        try {
            LOGGER.info("出口业务-外销-更新产品或配件状态 req=" + req.toString());
            exportContractService.updateProductOrPartsStatus(req);
            return R.build("");
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-更新产品或配件状态异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 根据产品编码规格编码获取规格信息
     * @param productCode 产品编码
     * @param specificationCode 规格编码
     * @return 规格信息
     */
    @GetMapping(value = "getProductInfoByCode")
    @ResponseBody
    public R getProductInfoByCode(String productCode, String specificationCode) {
        try {
            LOGGER.info("出口业务-外销-根据产品编码规格编码获取规格信息 productCode=" + productCode + ",specificationCode=" + specificationCode);
            ProductInfoRsp productInfo = exportContractService.getProductInfoByCode(productCode, specificationCode);
            return R.build(productInfo);
        } catch (Exception e) {
            LOGGER.info("出口业务-外销-根据产品编码规格编码获取规格信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }


}
